Memory access and detecting memory failures using dynamically replicated memory based on a replication policy

ABSTRACT

Dynamically replicated memory is usable to allocate new memory space from failed memory pages by pairing compatible failed memory pages to reuse otherwise unusable failed memory pages. Dynamically replicating memory involves detecting and recording memory faults, reclaiming failed memory pages for later use, recovering from detected memory faults, and scheduling access to replicated memory pages.

CROSS REFERENCE TO RELATED APPLICATION

This application is a continuation of U.S. patent application Ser. No. 14/033,992, filed Sep. 23, 2013, now abandoned, which is a divisional application from U.S. patent application Ser. No. 12/621,396, filed Nov. 18, 2009, now U.S. Pat. No. 8,543,863, issued Sep. 24, 2013, entitled “Efficiency of Hardware Memory Access using Dynamically Replicated Memory,” which relates to U.S. patent application Ser. No. 12/621,419, filed Nov. 18, 2009, now U.S. Pat. No. 8,255,742, issued Aug. 28, 2012, entitled “Dynamically Replicated Memory,” and is incorporated herein by reference.

BACKGROUND

For many years, dynamic random access memory (DRAM) has served as a fundamental building block in computer memory sub-systems. Over this time, memory capacity has significantly increased, with a correspondingly significant reduction in memory chip size. Such DRAM scaling has led to significant increases in the memory capacities of computer devices and an ever increasing number of portable devices. However, memory scaling is not without its problems.

As scaling increases, semiconductor memories reach densities at the atomic level. Unfortunately, at this level individual atoms and electrons likely have negative effects on data storage correctness. Potentially, incorrect data storage could lead to the end of DRAM scaling. In response, the memory chip industry may soon turn its attention to resistive-memory technologies such as phase-change memory (PRAM). PRAM is one of the most promising technologies to potentially replace DRAM because functional PRAM prototypes have been demonstrated at 22 nm, and they are projected to scale to 9 nm. Eventually, it is possible that PRAM, or other types of resistive memories, will replace most of the semiconductor memories, including those residing on the memory bus.

Currently, PRAM's greatest limiting factor is its write endurance. At the 65 nm technology node, a PRAM cell is expected to sustain 10⁸ writes before the cell's heating element breaks and induces a stuck-at fault (or hard failure), where writes are no longer able to change the value stored in the cell. Moreover, as PRAM scales to near-atomic dimensions, variability across device lifetimes increases, causing many cells to fail much sooner than in systems with lower variations. Unfortunately, existing systems for managing hard failures in DRAM and flash memory technologies do not map easily to PRAM. Accordingly, there is a need for low-overhead, accurate detection of hard failures, and a simple hardware-software interface that provides lossless recovery from such failures.

BRIEF SUMMARY

This summary is provided to introduce simplified concepts for dynamically replicating memory, which is further described below in the Detailed Description. This summary is not intended to identify essential features of the claimed subject matter, nor is it intended for use in determining the scope of the claimed subject matter. Generally, dynamically replicating memory involves detecting and recording memory faults, reclaiming failed memory pages for later use, recovering from detected memory faults, and scheduling access to replicated memory.

In one aspect, memory faults may be detected by writing data to a location of memory and then reading from the same location in memory. The written data is compared to the read data to determine if they match, and a parity bit is set such that an even number of “1”s exists in the block. If an error is detected in the block, yet the error is not signified by the parity bit, an additional bit is intentionally flipped to achieve the desired inconsistency.

In another aspect, failed memory pages may be reclaimed by discovering a failed location in memory and dynamically allocating new memory space to replace the failed location. This new memory space is allocated by pairing two or more compatible failed memory pages that do not contain failures in the same respective locations.

In another aspect, recovery from a memory fault may be accomplished by maintaining a ready list that contains the addresses of the newly available memory pages. The data intended for the failed memory page may then be written to the new memory pages.

In yet another aspect, access to replicated memory pages may be scheduled such that a memory access request is received from a memory controller, the memory access request is placed in a transaction queue, the data of both replicated memory pages are accessed, and the data from one of the pages is stored in memory or data from memory is stored in both of the replicated memory pages.

BRIEF DESCRIPTION OF THE DRAWINGS

The detailed description is set forth with reference to the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The use of the same reference numbers in different figures indicates similar or identical items.

FIG. 1 is a schematic diagram of an illustrative system for dynamically replicating memory in order to allocate new memory space.

FIG. 2 is a schematic diagram of illustrative compatible and incompatible pairs of faulty memory pages.

FIG. 3 is a schematic diagram of an illustrative dynamically replicated physical address space created with a physical-to-real address mapping.

FIG. 4 is a block diagram of a computer environment showing an illustrative system in which a dynamically replicated memory system can be implemented.

FIG. 5 is a schematic diagram of an illustrative error checking and reliable recording method using a parity bit and intentional bit flipping.

FIG. 6 is a flowchart illustrating details of an error checking and reliable recording method.

FIG. 7 is a schematic diagram of an illustrative method of dynamically replicating memory pages that contain faults.

FIG. 8 is a schematic diagram of an illustrative method of dynamically replicating memory pages that contain faults using an incoming list, an unmatched list, and a ready list.

FIG. 9 is a schematic diagram of an illustrative translation lookaside buffer (TLB) and an illustrative extended TLB usable for storing physical and real translation data of virtual page tags.

FIG. 10 is a flowchart illustrating details for use of an extended TLB.

FIG. 11 is a flowchart illustrating details for use of an extended TLB when caches are either virtually tagged or tagged with real addresses.

FIG. 12 is a schematic diagram of an illustrative method of recovering from memory faults.

FIG. 13 is a flowchart illustrating details of an illustrative method of recovering from memory faults.

FIG. 14 is a schematic diagram of an illustrative “lazy” replication policy for use with replicated memory systems.

FIG. 15 is a schematic diagram of an illustrative “eager” replication policy for use with replicated memory systems.

FIG. 16 is a flowchart illustrating details of an illustrative method of determining whether to use a “lazy” replication policy or an “eager” replication policy.

FIG. 17 is a flowchart illustrating details of an illustrative method of implementing a “lazy” replication policy (continued from A in FIG. 16).

FIG. 18 is a flowchart illustrating details of an illustrative method of implementing an “eager” replication policy (continued from B in FIG. 16).

DETAILED DESCRIPTION

Overview

This disclosure describes detection of and recovery from hardware memory failures. In particular, a hard failure detection mechanism is used to find the failures and then memory is dynamically replicated to allow for the graceful degradation of memory capacity.

As discussed above, PRAM is write-limited. That is, PRAM cells can only correctly record data up to a certain number of data writes. For example, at the 65 nm technology node, a PRAM cell is only expected to sustain 108 writes before the cell's heating element breaks and induces a stuck-at fault, where writes are no longer able to change the value stored in the PRAM cell. This limitation could potentially lead to large-scale capacity problems in computer systems of all types. This is because, historically, when a bit failure occurs on a PRAM page, the entire page must be decommissioned. Over the life of a computer device, this could translate to significant memory capacity reduction.

The techniques described in this disclosure solve the above problems by accurately detecting, and reliably recording memory failures, dynamically replicating memory to reclaim faulty memory pages for reuse, and gracefully recovering from detected memory faults without losing data. Additionally, a method of efficiently accessing replicated memory is disclosed that delivers dramatically better performance than for a baseline, unreplicated system.

For memory failure detection and recording, a low-overhead mechanism is used that leverages PRAM's failure modes and timing constraints regardless of the bit failure rate or the number of errors in each data block. More specifically, a data read is performed after every data write (a checker-read), and a parity bit is set such that the number of “1”s in each data block is always even. Furthermore, if an error is detected during the checker-read, and the parity bit has failed to signal the failure, an additional bit is intentionally flipped and the data is rewritten. Accordingly, failures are recorded by the parity bit as well.

Faulty memory can be reclaimed by the process of dynamic memory replication. One way to accomplish this task is to pair faulty memory pages together that contain failed memory blocks in different respective locations. For example, a memory page with a faulty bit in the first block can be paired with a memory page containing a faulty bit in the second block. As long as the two, or more, memory pages can combine to represent a fault-free memory page, and each block of memory can be represented fault-free, memory can be replicated. To achieve this, a pairing algorithm is used to pair compatible faulty memory pages.

Once a hard fault is detected, a memory controller will initiate recovery by copying the data to a new location in memory. In one example, in order to accomplish this task, the memory controller will make use of a ready table which contains a list of real pages (or real page pairs) available for use when a write failure occurs. The ready table functions as a circular buffer that allows the memory controller and the operating system to exchange pages. Data intended for a faulty page can be written to a pristine page, or a compatible pair (or compatible set) of pages from the ready table. Faulty pages are temporarily placed in the ready table for later pairing, and newly formed compatible pairs are placed in the ready table for use as replicated memory.

Accesses to primary and backup pages can be scheduled in at least two different ways: a “lazy” replication policy or an “eager” replication policy. Under the “lazy” replication policy, data reads (or writes) of the primary and backup pages take place sequentially. That is, the data access of the backup page is not executed until after the data access of the primary page is complete. Under the “eager” replication policy, data access to the primary and backup pages take place in parallel, with one access being canceled as soon as the first read (or checker-read following a write) returns with fault-free data.

FIG. 1 is a schematic diagram illustrating a high-level overview of a dynamic memory replication system 100 employed in an illustrative computer system 102. Memory 104 resides on computer system 102 and contains memory pages 106(1), 106(2) . . . 106(N) (collectively 106(1-N)). Memory pages 106(1-N) are made up of a mixture of pristine (non-faulty) memory pages and faulty memory pages. For example, memory page 106(1) is a pristine memory page as it has no faulty blocks, whereas faulty memory pages 106(2-5) each have at least one faulty block within the respective memory page. More specifically, memory page 106(2) has hard faults at memory block locations A, B, and E, memory page 106(3) has hard faults at memory block locations B and C, memory page 106(4) has a hard fault at memory block location D only, and memory page 106(5) has hard faults at memory block locations A and E.

Under a dynamically replicated memory system 100, two faulty memory pages can be paired to reclaim memory space by representing one non-faulty memory page 110. As seen in FIG. 1, memory pages 106(2) and 106(4) are a compatible pair of faulty memory pages 108, and can be paired to form a dynamically replicated page allocated from a compatible pair 110.

FIG. 2 is a schematic diagram further illustrating a compatible pair of memory pages 202 and an incompatible pair of memory pages 204. In this example, compatible pair 202 is made up of two faulty memory pages, faulty memory page 206 and faulty memory page 208. Each faulty memory page contains memory blocks A-E. Faulty memory page 206 and faulty memory page 208 form compatible pair 202 because all blocks are compatible blocks 210(A-E). In other words, compatible block 210(A) is compatible because at least one of faulty memory pages 206 and 208 contains a non-faulty block at location A. As seen in FIG. 2, this is true for every block location in compatible pair 202. As discussed above, by mapping the two faulty pages 206 and 208 together, one real page can be represented as a dynamically replicated page allocated from the compatible pair 110. In this way, two otherwise unusable memory pages 206 and 208 can be reused to form one usable memory page. Similarly, referring back to FIG. 1, two otherwise unusable memory pages 106(2) and 106(4) can be reused to form one dynamically replicated page allocated from a compatible pair 110 of faulty memory pages.

FIG. 2 also illustrates an incompatible pair of memory pages 204. In this example, incompatible pair 204 is made up of two faulty memory pages, 212 and 214, each containing memory blocks A-E. Faulty memory page 212 and faulty memory page 214 form incompatible pair 204 because not all blocks are compatible. For example, blocks 216(B-D) are compatible; however, both blocks 216(A) and 216(E) are incompatible because they both contain faults at the same block. Although memory pages 212 and 214 contain some compatible blocks 216(B-D), not all blocks are compatible for the pair. In other words, not every block in incompatible pair 204 can be represented by at least one of the faulty memory pages 212 and 214. If incompatible pair 204 was used to represent one dynamically replicated page allocated from a compatible pair 110, from FIG. 1, the data written to both incompatible blocks 216(A) and 216(E) would not be recoverable. On the other hand, if compatible pair 202 was used to represent one dynamically replicated page allocated from a compatible pair 110, the data written to every compatible block 210(A-E) would be recoverable.

FIG. 3 is a schematic diagram illustrating the two levels of indirection referenced above. In one aspect, memory pages in virtual address space 302(A-H) are mapped one-to-one to memory pages in physical address space 304(A-H). For example only, and not by way of limitation, FIG. 3 illustrates virtual page 302(A) mapping to physical page 304(B), virtual page 302(B) mapping to physical page 304(A), virtual page 302(G) mapping to physical page 304(E), and virtual page 302(H) mapping to physical page 302(H). These virtual-to-physical address mappings are recorded in a page table, discussed in further detail below. In another aspect, memory pages in physical address space 304(A-H) are mapped one-to-one, one-to-two, or one-to-many to memory pages in real address space 306(A-H). For example only, and not by way of limitation, FIG. 3 illustrates physical page 304(A) mapping, one-to-one, to real page 306(A); physical page 304(B) mapping, one-to-two, to real pages 306(B) and 306(C); and physical page 304(H) mapping, one-to-two, to real pages 306(G) and 306(H). In this example, real pages 306(B) and 306(C) correspond to the compatible pair dynamically replicated to represent physical page 304(B). Additionally, these virtual-to-physical address mappings are recorded in a real table, discussed in further detail below. In one aspect, the memory replication can occur immediately at start-up, replicating every memory page, or can be implemented dynamically, after each hard fault is detected.

FIGS. 1, 2, and 3 provide simplified examples of suitable memory architectures according to the present disclosure. However, other architectures and configurations are also possible. For example, while memory pages are shown and described as having five memory block locations (e.g., blocks A-E in FIG. 1), memory pages having greater or fewer memory blocks may also be used. Additionally, while an address space has been shown including eight memory pages (e.g., pages A-H in FIG. 3), in practice, address spaces (virtual, physical, and real) may contain more or less memory pages than shown.

While dynamically replicated memory systems and methods are described in the context of PRAM, the concepts described herein are broadly applicable to computer systems employing other types of memory hardware or architecture. For example, dynamically replicated memory may be advantageous for use with main memory, cache memory, and RAM subsystems, as well as with all types of resistive memory type chips, including: PRAM, Spin-Torque Transfer Magnetoresistive RAM (STT-MRAM), Ferroelectric RAM (FRAM), and Resistive RAM (RRAM) such as memristors.

Additionally, while the “lazy” and “eager” policies for accessing replicated data are described in the context of PRAM and other resistive memory designs, the methods described herein are broadly applicable to increasing memory access performance for virtually any type of computer system employing any type of memory hardware or architecture. For example, the “lazy” and “eager” replication policies are also applicable for use with static random access memory (SRAM), DRAM, and other types of memory technologies. For example, the “eager” policy may provide better performance than a baseline, unreplicated system when failures are rare, and minimizes performance overhead at the end of the device lifetime when failures are more common. Therefore, dynamically replicated memory methods and associated access policies have a wide area of application.

Illustrative Computing Environment

FIG. 4 provides an illustrative overview of one computing environment 400 in which aspects of the disclosure may be implemented. The computing environment 400 may be configured as any suitable computing device capable of implementing a dynamically replicated memory system. By way of example and not limitation, suitable computing devices may include personal computers (PCs), servers, server farms, datacenters, or any other device using memory technologies that are susceptible to failure of memory blocks.

In one illustrative configuration, the computing environment 400 comprises at least a memory 402 and one processing unit 404. The processing unit 404 may be implemented as appropriate in hardware, software, firmware, or combinations thereof. Software or firmware implementations of the processing unit 404 may include computer- or machine-executable instructions written in any suitable programming language to perform the various functions described.

Memory 402 may store program instructions that are loadable and executable on the processor 404, as well as data generated during the execution of these programs. Depending on the configuration and type of computing device, memory 402 may be volatile (such as RAM) and/or non-volatile (such as ROM, flash memory, etc.). The computing device or server may also include additional removable storage 406 and/or non-removable storage 408 including, but not limited to, magnetic storage, optical disks, and/or tape storage. The disk drives and their associated computer-readable media may provide non-volatile storage of computer readable instructions, data structures, program modules, and other data for the computing devices. In some implementations, the memory 402 may include multiple different types of memory, such as PRAM and at least one other type of memory, such as SRAM, DRAM, or ROM.

Memory 402, removable storage 406, and non-removable storage 408 are all examples of computer readable storage media. For example, computer-readable storage media may include volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Memory 402, removable storage 406, and non-removable storage 408 are all examples of computer storage media. Additional types of computer storage media that may be present include, but are not limited to, PRAM, SRAM, DRAM, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can accessed by the server or other computing device. Combinations of the any of the above should also be included within the scope of computer-readable media.

The computing environment 400 may also contain communications connection(s) 410 that allow the computing environment 400 to communicate with a stored database, another computing device or server, user terminals, and/or other devices on a network.

The computing environment 400 may also include input device(s) 412 such as a keyboard, mouse, pen, voice input device, touch input device, etc., and output device(s) 414, such as a display, speakers, printer, etc.

Turning to the contents of the memory 402 in more detail, the memory 402 may include an operating system 416 and one or more application programs or services for implementing the dynamic memory replication system 100. In one implementation, the memory 402 includes a memory controller module 418. The memory controller module 418 may be configured to manage the flow of data going to and from the main memory. In one aspect, the memory controller module 418 is located in the memory 402 as shown in FIG. 2. Alternatively, however, the memory controller module 418 may be located onboard the processor 404. As discussed in further detail, memory controller module 418 may also be configured to detect faulty memory, tracking replicated memory addresses, and accessing replicated memory.

The memory 402 further includes a translation lookaside buffer (TLB) module 420, a page table module 422, a real table module 424, a ready table module 426, and a hardware page walker module 428. The TLB module 420 may be configured to store virtual-to-physical address translations and, as will be discussed in further detail, physical-to-real address translations. In one aspect, the TLB module 420 is configured to extend a standard TLB by at least one and half its original width. The page table module 422 may be configured to store virtual-to-physical address mappings. The real table module 424 may be configured to store physical-to-real address mappings. In one aspect, the real table is stored in a global location of the memory 402. The ready table module 426 may be configured to store a list of memory pages, both pristine memory pages and compatible pairs of faulty memory pages, the memory pages are available for use by the memory controller 418. In one aspect, the ready table module 426 is stored in a region of memory 402 that is not made up of PRAM. The hardware page walker module 428 is configured to read the contents of multiple memory locations and use the data to compute physical and real addresses.

Detecting and Reliably Recording Memory Faults

FIG. 5 depicts a schematic diagram illustrating a data block with no error 502, a data block with detectable error 504, a data block with undetectable error 506, a data block with detectable error and flipped bit 508, as well as parity bit 510 that is used to help detect and record the memory faults. By way of example, and not limitation, each data block contains eight bits plus one parity bit 510. However, virtually any sized data block may be used. The parity bit may reside anywhere in the data block. However, in the illustrated example, the parity bit resides at the end of the data block. The parity bit 510 is set by the memory controller 418 such that the total number of “1”s in the codeword including the parity bit (parity plus data) is even at each point in time.

The data block with no error 502 contains no bit errors and, therefore, the parity bit 510 is set to “0”. This maintains the even parity and signals to the memory controller 418 that this block is error free. In another aspect, data block with detectable error 504 contains one fault 512. Due to the odd number of faults, the memory controller 418 sets the parity bit 510 to “1”, thus maintaining even parity and recording that data block with detectable error 504 contains an error. In yet another aspect, data block with undetectable error 506 contains two faults, fault 514 and fault 516. Due to the even number of faults, the memory controller 418 sets the parity bit 510 to “0”, again maintaining even parity. However, in this situation the memory fault will go undetected because the parity bit is never set to “1”. The next time data is written to data block with undetectable error 506, the memory controller 418 will detect fault 514 and fault 516 and will also detect that the parity bit 510 failed to record the error. To correct the undetectable error, memory controller 418 will set intentionally flipped bit 518 to “1”. Intentionally flipped bit 518 can be any non-faulty bit in the block. Upon setting intentionally flipped bit 518 to “1”, memory controller 418 will then set the parity bit 510 to “1”, thus maintaining even parity and recording that data block with detectable error and flipped bit 508 contains an error. Thus, as seen in data block with detectable error and flipped bit 508, an even number of “1”s exists, intentionally flipped bit 518, fault 520, fault 522, and parity bit 510. Additionally, due to the existence of intentionally flipped bit 518, data block with undetectable error 506 becomes data block with detectable error and flipped bit 508, and the parity bit 510 is now able to record the error.

FIG. 6 is a flowchart of one illustrative method 600 for detecting and reliably recording memory faults. The method 600 may, but need not necessarily, be implemented using the dynamic memory replication system 100 shown in FIG. 1. In this particular implementation, the method 600 begins at optional block 602 in which the memory controller 418 loads the next block of data to be written to memory. At block 604, the memory controller 418 writes the loaded data to a location in memory. At block 606, the memory controller 418 counts the number of “1”s in the block of data and sets the parity bit 510 such that the codeword (parity plus data) contains an even number of “1”s. At block 608, the memory controller 418 reads the data that was just written to the memory location (the checker-read) to compare the read data to the written data. This approach is possible because writes are much more expensive (in terms of both latency and energy) compared to reads in PRAM. By issuing the checker-read of method 600 after each array write to PRAM, the read latency is largely amortized over the write latency, with only a small impact on overall system performance.

As indicated at decision block 610, the method 600 determines whether the data read from the memory location above is consistent with the data written to the same memory location. If so, the method 600 terminates by returning to optional block 602. If the read data does not equal the written data, the method 600 determines at decision block 612 whether the number of “1”s in the codeword is even and the parity bit 510 is set to “1”. If not, the method 600 determines at decision block 614 if all bits in the memory block are faulty. If not, at block 616, the memory controller 418 intentionally flips a bit. The bit that is flipped must be at a non-faulty position in the memory block. Then, at block 604 the data is rewritten to the same memory block. This way, the checker-read can once again determine if the error was detected. If, however, the method 600 determines at decision block 620 that all the bits in the memory block are faulty, the method 600 terminates at block 618 by signaling the operating system 416 to proceed to the recovery mechanism 1300 of FIG. 13.

Referring back to decision block 612, if the number of “1”s in the codeword is even and the parity bit 510 is set to “1”, the method 600 determines at decision block 620 whether a backup page exists. In other words, whether the memory page is being written to part of a dynamically replicated pair. If so, the memory controller 418 writes the data to the backup page at block 622 and proceeds back to the checker-read at block 608. On the other hand, if no backup page exists, the method 600 terminates at block 622 by signaling the operating system 416 to proceed to the recovery mechanism 1300 of FIG. 13.

Dynamically Replicating Memory

FIG. 7 provides a schematic diagram illustrating a dynamically replicated memory method 700 in an illustrative memory module 702. In this example, memory 702 contains at least one first page 704, containing at least data blocks A-E, a second page 706 containing at least data blocks A-E, and a dynamically replicated pair of faulty memory pages representing one non-faulty memory page 708, containing at least data blocks A-E and A′-E′. In one aspect, the memory controller 418 may attempt to write the data of first page 704 to second page 708 prior to determining that second page 706 has a faulty block at location B. In order to store the data intended for second page 706 without data-loss, the pair of pages 708 is dynamically replicated to represent the second page 706, and the data is written to dynamically replicated pair of faulty memory pages representing one non-faulty memory page 708. Data blocks 708(A′-E′) represent the backup data blocks (or replicas) of data blocks 708(A-E). In other words, data page 708(A′-E′) is a replica of data page 708(A-E).

First page of data blocks 704(A-E) may be written to second page of data blocks 706(A-E) as part of any regular data manipulation functionality of illustrative computing device 102 such as, for example, data written to a cache, data written to PRAM, SRAM, DRAM, main memory, or data written to removable storage 406 or non-removable storage 408.

In one aspect, second page of data blocks 706(A-E) is error free (not shown). In that case, first page of data blocks 704(A-E) is written to second page of data blocks 706(A-E) without requiring a dynamically replicated pair of pages representing a page of data blocks 708(A-E, A′-E′). However, in another aspect, first page of data blocks 706(A-E) has at least one faulty data block. In the example of FIG. 7, the faulty data block is represented as data block 706(B). In other examples, the second page of data blocks 706(A-E) could contain faulty data blocks at any combination of locations, or at all data block locations.

In the illustrated implementation, each block of data (A-E) of first page of data blocks 704(A-E) is written to each block of data (A-E) of second page of data blocks 706(A-E). For example, any combination of data blocks (A-E) could be written from first page of data blocks 704(A-E) to second page of data blocks 706(A-E). In FIG. 7, because all data blocks A-E are written to second page of data blocks 706(A-E), and at least one data block is faulty, the dynamically replicated memory method 700 will signal the memory fault recovery method 1300, discussed in further detail below. As part of the memory fault recovery method 1300, the data of first page of data blocks 704(A-E) that was written to second page of data blocks 706(A-E) will then be written to dynamically replicated pair of pages representing a page of data blocks 708(A-E, A′-E′). In this way, the two previously unusable faulty memory pages can be reused to store the data from first page of data blocks 704(A-E) without causing a software failure or hang. More specifically, each data block A-E from first page of data blocks 704(A-E) will be written to both pages in the dynamically replicated pair representing a page of data blocks 708(A-E) and 708(A′-E′). As discussed above, because both pages in the pair 708(A-E) and 708(A′-E′) are compatible, each data block is represented at least once, and none of the data from first page of data blocks 704(A-E) is lost.

In one aspect, dynamically replicated pair 708 may be made up of any number of compatible faulty memory pages. For example, dynamically replicated pair 708 may be comprised of three compatible faulty memory pages, where each memory block location may be represented by at least one of the three faulty memory pages. In this way, three, or more, otherwise unusable memory pages can be combined to dynamically replicate one pristine memory page.

FIG. 8 provides a schematic diagram illustrating a dynamic pairing algorithm 800 stored in memory module 104 (not shown) and executed on illustrative processor 404. Memory 104 contains an incoming list of faulty memory pages 802(1-N), an unmatched list of faulty memory pages 804(1-N), and a ready list of pristine and compatible pairs of memory pages 806(1-N). Incoming list of faulty memory pages 802(1-N) contains faulty memory pages that have either been recently detected as faulty or recently detected as incompatible with its pair. Memory pages in the incoming list of faulty memory pages 802(1-N) have not been compared with other faulty pages since the last immediate failure detection or incompatibility detection of the page.

The unmatched list of faulty memory pages 804(1-N) contains faulty memory pages that have already been compared to each and every other faulty memory page in the unmatched list of faulty memory pages 804(1-N). Faulty memory pages that are incompatible with all other faulty memory pages in the unmatched list of faulty memory pages 804(1-N) remain in the unmatched list of faulty memory pages 804(1-N) until a new match is found. In this example a new match will be found when a new faulty page from the incoming list of faulty memory pages 802(1-N) is determined to be a compatible match with a faulty memory page already in the unmatched list of faulty memory pages 804(1-N).

The ready list of pristine and compatible pairs of memory pages 806(1-N) contains both pristine memory pages (pages with no faults) and compatible pairs of faulty memory pages (dynamically replicated memory), such as compatible pair 808. The pages and compatible pairs, like compatible pair 808 in read list 806(1-N), are ready for consumption by the dynamically replicated memory method 700.

In order to fill the ready list 806(1-N), the dynamic pairing algorithm 800 takes the first page in the incoming list 802(1) and compares it to each faulty page in the unmatched list 804(1-N). For example, and not by way of limitation, FIG. 8 shows the comparing process beginning with incompatible pair 810. As discussed above, the faulty pages of incompatible pair 810 are incompatible because not every memory block can be represented by the pair. More specifically, memory blocks A and E are faulty in both pages of incompatible pair 810; therefore, they are incompatible. Dynamic pairing algorithm 800 then leaves the unmatched page that already existed in the unmatched list 804(1-N) in its current position in the unmatched list 804(1-N) and continues to compare the first page of the incoming list 802(1) with the next page in the unmatched list 804(1-N). FIG. 8 also shows incompatible pair 812 as another example of two faulty pages that do not match. The faulty pages of incompatible pair 810 are incompatible because the memory block at location A is faulty in both pages. Again, dynamic pairing algorithm 800 leaves the unmatched page that already existed in the unmatched list 804(1-N) and continues to compare the first page of the incoming list 802(1) with the next page in the unmatched list 804(1-N) until a match is found. Compatible pair 808 is an example of a match. In this example, the two faulty pages of compatible pair 808 do not share any data block locations with errors. More specifically, each data block (A-E) can be represented by at least one page in the pair. Dynamic pairing algorithm 800 then places compatible pair 808 in the ready list 806(1-N) for consumption by the dynamically replicated memory method 700 and starts the process over with the next page in the incoming list 802(2) (not shown).

If, however, the first page in the incoming list 802(1), or any page thereafter 802(2-N) (not shown) is not compatible with any pages in the unmatched list 804(1-N), the incompatible faulty page will be placed in the unmatched list 804(1-N) for later attempts at matching. This process is repeated by the dynamic pairing algorithm 800 until all pages in the incoming list 802(1-N) are either paired up with a compatible page and placed in the ready list 806(1-N) or determined to be incompatible with all faulty pages in the unmatched list 804(1-N) and placed in the unmatched list 804(1-N).

In one aspect, the dynamic pairing algorithm 800 will be executed by the operating system 416 based on an interrupt called by the memory controller 418. This interrupt may cause the operating system 416 to signal a high-priority kernel thread whose sole job is to refill the ready list 806(1-N). In another aspect, the addresses of the pages in the ready list 806(1-N) are stored in the ready table 426. In yet another aspect, the dynamic pairing algorithm 800 is implemented by the memory controller. In yet another aspect, the incoming list 802(1-N) and the unmatched list 804(1-N) are maintained by the operating system 416 as two linked lists of real pages.

In one aspect, multiple faulty memory pages are combined to replicate one pristine memory page. For example, the ready list 806, may contain, pristine memory pages, compatible pairs of memory pages, and compatible combinations of any number of memory pages. In this way, two or more incompatible memory pages may become compatible by the addition of a third, or more, memory pages that complete the compatibility. As described above, as long as each memory block location may be represented by at least one of the faulty memory pages in the compatible combination, data loss can be avoided by use of the replicated memory page. Additionally, the dynamic pairing algorithm 800 may order the combined memory pages in such a way that memory pages with fewer errors are placed closer to the front of the list of the compatible combination. In other words, the dynamic pairing algorithm 800 may be configured to associate memory pages with fewer errors as the primary memory page in the replicated group, or pair, and to associate memory pages with more errors as the backup pages, or page, in the replicated group, or pair. This configuration may potentially decrease the number of backup page accesses during data reads and writes.

FIG. 9 provides a schematic diagram of a standard translation lookaside buffer (TLB) 420, and an extended TLB 902 stored in memory 402 (not shown). A standard TLB contains two columns, the first for storing virtual page tags 904(A-H), and the second for storing physical translation data 906(A-H). Each row (A-H) in each column, contains the associated virtual page tags 904(A-H) and physical translation data 906(A-H) for each page in memory 402. More specifically, for memory page A, virtual page tag 904(A) stores the metadata associated with the virtual page of memory page A and physical translation data 906(A) stores the translation from the virtual address of memory page A to the physical address of memory page A, in other words, the virtual-to-real address mapping for memory page A. In order to accommodate real addresses, along with the virtual page tag column 908(A-H) and physical translation data column 910(A-H), extended TLB 902 must also contain an additional column for real translation data 912(A-H). Real translation data column 912(A-H) stores the translation from the physical addresses to the virtual address. More specifically, in reference to memory page A again, real translation data column 912(A-H) stores the physical-to-real address mapping for memory page A, signified by A′. In one aspect, some memory pages are not replicated, for example memory page B in extended TLB 902 has not been replicated. In this situation there will not be a physical-to-real address mapping for memory page B, therefore, there is no B′ in row B of extended TLB 902.

FIG. 10 is a flowchart of one illustrative method 1000 for tracking the real addresses of memory pages. The method 1000 may, but need not necessarily, be implemented using the dynamic memory replication system 100 shown in FIG. 1. In this particular implementation, the method 1000 begins at optional decision block 1002 in which the memory controller 418 determines if a TLB 420, or extended TLB 902, miss has occurred for a memory page that is requested. If not, the method 1000 terminates at block 1004 where the address stored in the TLB 420, or extended TLB 902, is sent to the memory controller 418. On the other hand, if a TLB 420, or extended TLB 902, miss has occurred at decision block 1002, at block 1006 a hardware page walker 428 accesses the page table 422 to receive the virtual-to-physical address mapping of the memory page. The hardware page walker 428 then accesses the real table 424 to receive the physical-to-real address mapping of the memory at block 1008, stores the real address in the TLB 420, or extended TLB 902 at block 1010, and then terminates at block 1012 where the address is sent to the memory controller 418 for further processing.

FIG. 11 is a flowchart of one illustrative method 1100 of further tracking the real addresses of memory pages when the caches of computer system 102 are either virtually indexed and virtually tagged, or virtually indexed and tagged with real addresses. The method 1100 may, but need not necessarily, be implemented using the dynamic memory replication system 100 shown in FIG. 1. In this particular implementation, the method 1100 begins at optional decision block 1102 in which the memory controller 418 determines whether the caches are virtual. If not, meaning the caches are neither virtual nor real, the method 1100 determines at decision block 1104 whether the caches are real. If not, the method 1100 terminates at block 1106 by signaling that a TLB 420, or extended TLB 902, miss has occurred and executing method 1000 of FIG. 10. Otherwise, if the caches are real, referring back to decision block 1104, the hardware page walker 428 accesses the TLB 420, or the extended TLB 902 at block 1108 and obtains the virtual-to-real address mapping at block 1110. At decision block 1112, the memory controller 418 determines whether a last level cache miss has occurred. If not, the method 1100 terminates at block 1114 by sending the appropriate data to the processor core 404. On the other hand, back to decision block 1112, if a last level cache miss occurred, the hardware page walker 428 accesses the TLB 420, or the extended TLB 902, at block 1116, obtains the addresses of both real pages associated with the requested memory page at block 1118, and terminates at block 1120 by sending the address, or addresses, to the memory controller 418.

Referring back to decision block 1102 of FIG. 11, if the caches are virtual, meaning they are virtually indexed and virtually tagged, the method 1100 determines at decision block 1122 whether a last level cache miss occurred. If not, the method terminates at block 1114 by sending the appropriate data to the processor core 404. On the other hand, if a last level cache miss has occurred, the hardware page walker 428 will access the TLB 420, or the extended TLB 902, at block 1124, obtain the virtual-to-real address mapping for the requested memory page at block 1126, and terminate at block 1120 by sending the address, or addresses, to the memory controller 418.

Recovering from Memory Faults

FIG. 12 provides a schematic diagram of a memory controller 1202 and a ready table 1204, both before and after the executing of the memory fault recovery method 1300 of FIG. 13, to be discussed in further detail below. Illustrative memory controller 1202(1), prior to the execution of the recovery method 1300, and illustrative memory controller 1202(2), after the execution of the recovery method 1300, reside in memory 104 (not shown) along with both level 2 and level 1 caches which are well known by those skilled in the art and others. Additionally, ready tables 1204(1) and 1204(2), which represent ready table 1204 before and after the execution of recovery method 1300 respectively, contain an operating system pointer (OS Pointer) 1206 and a memory controller pointer (MC Pointer) 1208. Similarly, OS Pointers 1206(1) and 1206(2) as well as MC Pointers 1208(1) and 1208(2) represent the respective pointers 1206 and 1208 before and after the execution of recovery method 1300.

FIG. 12 also provides schematic diagrams of memory pages 1210(1-N), 1212(1-N), 1214(1-N), and 1216(1-N). As seen in FIG. 12, each set of memory pages resides on a different memory bank, respectively, memory banks 1218, 1220, 1222, and 1224. For example only, and not by way of limitation, memory pages 1210(1-N) are made up of primary memory page A, primary memory page B, and primary memory C, memory pages 1212(1-N) are made up of backup page B′, memory pages 1214(1-N) are made up of backup page A′ and primary page C, and memory pages 1216(1-N) are made up of backup page C′. The significance here is that each backup page, namely A′, B′, and C′, resides on a different memory bank than its respective primary page.

By way of example, and not limitation, the ready table 1220 functions as a circular buffer that allows the memory controller 418 and the operating system 416 to exchange memory pages. As described above, the operating system 416 places compatible pairs or pristine pages in to the ready table 1220, and the memory controller 418 consumes these pages and replaces them with incompatible pages that must be re-paired. The ready table 1220 uses the OS Pointer 1206 and the MC Pointer 1208 to indicate which part of the ready table 1220 is which. Entries from the MC Pointer 1208 up to the OS Pointer 1206 (exclusive) are ready for the memory controller 418 to use, and entries from the OS Pointer 1206 to the MC Pointer 1208 (exclusive) are dead pages for the operating system 416 to handle. If both OS Pointer 1206 and MC Pointer 1208 point to the same location, then all pairs are ready for the memory controller 418.

Ready table 1204 is made up of two columns in order to accommodate the possibility of a pair of memory pages. Ready table 1204 contains a list of real pages (or real page pairs) available to use when a write failure occurs. In one aspect, the ready table 1204 is a 128-entry SRAM array co-located with the controller's scheduling queue. Each table entry may contain space for two 32-bit values indicating the real addresses for the pages supplied by operating system 416. These values can indicate either a pair of pages or a single pristine page, in which case the second value would be 0xFFFFFFFF. In another aspect, the ready table 1204 is kept in volatile memory, so that it can be reconstructed when the computer system 102 is powered-up.

As show in FIG. 12, ready table 1204(1), prior to execution of the fault recovery method 1300, contains two compatible pairs of memory pages ready for consumption by the memory controller 418. The first compatible pair is made up of primary memory page B and backup memory page B′, and the second compatible pair is made up of primary memory page C and backup memory page C′. By way of example, if the memory controller 418 attempts to write data to compatible pair A and A′, and the write fails for both locations, A and A′, the memory controller 418 will detect the fault via the checker-read and then initiate the fault recovery method 1300 by copying the data to a new location in memory. In this case, the new location in memory is located at MC Pointer 1208(1); therefore, the data will be written to primary page B and backup page B′. Additionally, the faulty pages, A and A′, will be written into the ready table at location MC Pointer 1208(1) and MC Pointer will be incremented to position MC Pointer 1208(2).

FIG. 13 is a flowchart of one illustrative method 1300 for recovering from memory faults. The method 1300 may, but need not necessarily, be implemented using the dynamic memory replication system 100 shown in FIG. 1. In this particular implementation, the method 1300 begins at optional decision block 1302 in which the memory controller 418 determines whether data cannot be written to a once pristine memory page with a new fault or whether the compatibility between paired memory pages breaks. If not, the method 1300 terminates at block 1304 and the memory controller proceeds to load the next data block for data write, block 602 of error detection method 600. If, however, the compatibility between memory pages breaks, at block 1306 the memory controller 418 will signal the processor cores to flush their pipelines and stop fetching instructions. At block 1308, the memory controller 418 will get either the address of the next available page or the addresses of the next available pages that are located in the ready table 426, located at MC Pointer 1208. At block 1310, memory controller 418 will copy the data from the faulty page, or pages, to the new page, or pages, from the ready table 426. At decision block 1312, the memory controller 418 will determine whether the new page is faulty or whether the new pages are incompatible. If the new page is faulty or the new pages are incompatible, at block 1314 the memory controller 418 will increment MC Pointer 1208 and then get the address(es) of the next available page(s) in the ready table 1204 at block 1308.

However, at decision block 1312, if the memory controller determines that either the new page is not faulty or the new pages from ready table 1204 are compatible, at block 1316, the memory controller 418 will overwrite the addresses of the faulty page(s) in the ready table 1204 at location MC Pointer 1208. At block 1318, the MC Pointer 1208 will be incremented to signify to the operating system 416 that faulty pages or a pair of faulty pages are waiting to be re-paired. At block 1320, the memory controller 418 will initiate both level 1 and level 2 cache flushes to send the data in the cache to the new memory page(s). At block 1322, the real table 424 will be updated with the new physical address of the virtual memory page. At decision block 1324, the memory controller 418 will determine whether the new pair of pages become incompatible during the cache flush. If not, the method 1300 terminates at block 1304 and the memory controller proceeds to the error detection method 600. Otherwise, at decision block 1326, the memory controller 418 determines whether the new page is unrecoverable. If so, the method 1300 terminates at block 1328 by decommissioning the memory page so that it is never used again. Otherwise, if the page is recoverable, the method 1300 returns to block 1306, in order to signal the processor core 404 to once again flush the pipelines, stop fetching instructions, and begin the process over again as if a compatibility break had been detected.

Scheduling Access to Primary and Backup Pages

As discussed above accesses to primary and backup pages can be scheduled in at least two different ways: a “lazy” replication policy or an “eager” replication policy. FIG. 14 is a schematic diagram illustrating a “lazy” replication policy 1400 for scheduling access to replicated memory pages. In FIG. 14, the replicated memory page 1402 resides on memory bank 1404 and the replicated memory page 1406 resides on memory bank 1408. The two replicated memory pages 1402 and 1406 are represented by A and A′, with A being the primary page in the pair and A′ being the backup page in the pair. The “lazy” replication policy 1400 also relies on transaction queue 1410 for scheduling memory reads and writes.

Under the “lazy” replication policy 1400, data reads (and writes) of the primary and backup pages take place sequentially. That is, the memory page accessing is scheduled such that access to the backup page always occurs after the access to the primary page. For certain memory architectures this may have certain specific performance benefits.

In one aspect, when memory access is required a primary page write instruction 1412 is inserted into the transaction queue 1410 and the memory controller 418 performs a data write to the primary page 1414. The insertion of the backup write instruction 1416 into the transaction queue 1410 is not performed by the memory controller 418 until after the checker-read from the primary page 1418 returns with fault-free data. If the data read from the primary page 1418 is fault-free then the memory controller 418 terminates the “lazy” replication policy and writes the non-faulty data from the primary page to a location in memory. The data can then be consumed by the operating system 416. However, if the data read from the primary page 1418 is faulty, then memory controller 418 inserts the backup write instruction 1416 into the transaction queue and the write to backup page 1420, followed by the checker-read from backup page 1422 is performed.

FIG. 15 is a schematic diagram illustrating an “eager” replication policy 1500 for scheduling access to replicated memory pages. In FIG. 15, the replicated memory page 1502 resides on memory bank 1504 and the replicated memory page 1506 resides on memory bank 1508. The two replicated memory pages 1502 and 1506 are represented by A and A′, with A being the primary page in the pair and A′ being the backup page in the pair. The “eager” replication policy 1500 also relies on transaction queue 1510 for scheduling memory reads and writes.

In one aspect, under the “eager” replication policy 1500, data writes to the primary and backup pages take place in parallel. That is, the memory page accessing is scheduled such that requests for access to the primary page and the backup page take place at almost exactly the same time. The fact that memory pages 1502 and 1506 reside on different memory banks 1504 and 1508 makes this possible. For certain memory architectures this may have certain specific performance benefits. In particular, for dynamically replicated memory there is a dramatic impact on overall system performance. Additionally, the “eager” replication policy 1500 offers significant performance enhancements over non-replicated memory systems as well.

In one aspect, under the “eager” replication policy 1500, when memory access is required a primary page read instruction 1512 is inserted into the transaction queue 1510 followed immediately by the backup page read instruction 1514. Here, the memory controller 418 sends the data read request for the primary page 1516 and the data read request for the backup page 1518 in parallel. As soon as the first of either the read from the primary page 1520 or the read from the backup page returns with fault free data, the data can immediately be consumed by the operating system 416 without needing to wait for the other read to return. However, if the data read from the first returned read is faulty, then memory controller 418 must wait for the second read to return with fault free data.

FIG. 16 is a flowchart of one illustrative method 1600 for scheduling access to replicated memory pages. The method 1600 may, but need not necessarily, be implemented using the dynamic memory replication system 100 shown in FIG. 1. In this particular implementation, the method 1600 begins at optional decision block 1602 in which the operating system 416 determines whether to use the “eager” replication policy. Under certain circumstances the “lazy” replication may be preferred. In other cases the “eager” replication may offer performance benefits. If an “eager” replication policy is not optimal, at block 1604 the operating system 416 will perform the “lazy” replication policy detailed in FIG. 14. However, if an “eager” replication policy is optimal, at block 1606 the operating system 416 will perform the “eager” replication policy detailed in FIG. 15.

FIG. 17 is a flowchart of one illustrative method 1700 for scheduling access to replicated memory pages under a “lazy” replication policy as already described in reference to FIG. 14. The method 1700 may, but need not necessarily, be implemented using the dynamic memory replication system 100 shown in FIG. 1. In this particular implementation, the method 1700 begins at block 1702 where the memory controller 418 inserts a read request for the primary page into its transaction queue. At block 1704, the read request returns with data from the primary page. Because the “lazy” replication policy reads data from the replicated memory pages sequentially, the memory page must be checked for errors prior to inserting the request to read the backup page. Therefore, at block 1706, the memory controller 418 checks the parity bit of the data returned from the primary page. At decision block 1708, the memory controller 418 determines whether the primary page is faulty. If not, the data is valid and the method terminates at block 1712 by writing the data to a location in memory 402 for consumption by the operating system 416 if necessary. However, if a fault is detected in the primary page, at block 1714 the memory controller 418 inserts a read request for the backup page into its transaction queue. At block 1716, the read request returns with the data from the backup page, and the method terminates at block 1718 by writing the data from the backup page to a location in memory 402 for consumption by the operating system 416 if necessary. In another aspect, the data access being scheduled is a data write. In that case, once both checker-reads return with no errors, the “lazy” replication policy 1400 terminates without writing the data to a location in the memory.

FIG. 18 is a flowchart of one illustrative method 1800 for scheduling access to replicated memory pages under an “eager” replication policy as already described in reference to FIG. 15. The method 1800 may, but need not necessarily, be implemented using the dynamic memory replication system 100 shown in FIG. 1. In this particular implementation, the method 1800 begins at decision block 1802 where the memory controller 418 determines whether the data access being scheduled is a data write. If so, at block 1804 the memory controller 418 inserts a write request for both the primary page and the backup page into its transaction queue so that both data writes are performed in parallel. At block 1806, the memory controller 418 waits for both checker-reads to complete, and the method terminates at block 1808 by removing both the primary and backup requests from the transaction queue.

On the other hand, at decision block 1802, if memory controller 418 determines that the data access being scheduled is not a write (rather, it is a data read) then at block 1810, memory controller 418 inserts a read request for both the primary page and the backup page into the transaction queue so that both data reads are performed in parallel. At decision block 1812 the memory controller 418 determines whether the first returning set of data is fault-free. The first returning data could be either the data read from the primary memory page or the data read form the backup memory page. In either event, the following steps are the same. If the memory controller 418 determines at decision block 1812 that the first returning data is fault-free, at block 1814 it removes both the primary and backup requests from the transaction queue and the method 1800 terminates at block 1816 by writing the first returning data to a location in memory 104 for further processing.

However, if the memory controller 418 determines at decision block 1812 that the first returning data is not fault-free, at block 1818 it waits for the next returning data. In one aspect, if the first returning data was the data read from the primary memory page then memory controller 418 will be waiting for the data read from the backup memory page. In another aspect, if the first returning data was the data read from the backup memory page then memory controller 418 will be waiting for the data read from the primary memory page.

At decision block 1820, memory controller 418 determines if the next returning data is fault-free. In one aspect, as described above, all data fault checking is done by the data checking method 600. If the next returning data is fault-free, the method 1800 terminates at block 1822 by writing the next returning data to a location in memory for further processing. On the other hand, if the next returning data is not fault-free, the next returning data is combined with the first returning data in order to represent one fault-free page of data at block 1824, and the method 1800 terminates at block 1826 by writing the reconstructed data to a location in memory 104 for further processing.

In one aspect, the location in memory 104 to which data is written whenever method 1800 terminates is a cache in the memory 104 of computer system 102. In another aspect, the location in memory is PRAM, SRAM, DRAM, or main memory. In yet another aspect, the location in memory is not limited to any particular type of memory or architecture.

Illustrative methods of error detection, dynamic memory replication, memory fault recovery, and replicated memory access scheduling are described above. Some or all of these methods may, but need not, be implemented at least partially by an architecture such as that shown in FIG. 4. It should be understood that certain acts in the methods need not be performed in the order described, may be rearranged, modified, and/or may be omitted entirely, depending on the circumstances. Also, any of the acts described above with respect to any method may be implemented by a processor or other computing device based on instructions stored on one or more computer-readable media.

CONCLUSION

The subject matter described above can be implemented in hardware, or software, or in both hardware and software. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts are disclosed as illustrative forms of implementing the claimed subject matter. For example, the methodological acts need not be performed in the order or combinations described herein, and may be performed in any combination of one or more acts. 

What is claimed is:
 1. One or more computer-readable storage media storing computer-executable instructions that, when executed by one or more processors, cause the one or more processors to perform acts for improving memory access performance, the acts comprising: determining a replication policy to follow; replicating a first memory page to create a second memory page, the first memory page and the second memory page including data and located on different memory banks of a memory; receiving a memory access request for the data from a memory controller, the data being included in a set of faulty memory pages including at least a first memory page and a second memory page, wherein the first memory page includes a first failed memory block that is located at a relative position different from a second failed memory block of the second memory page; requesting a first memory access to the data of the first memory page and requesting a second memory access to the data of the second memory page; receiving the data of the first memory page at the memory controller; determining whether the data of the first memory page is faulty; and waiting to receive the data of the second memory page in response to determining that the data of the first memory page is faulty.
 2. The one or more computer-readable storage media of claim 1, the acts further comprising: receiving and consuming the data of the first memory page at the memory controller without waiting for the data of the second memory page.
 3. The one or more computer-readable storage media of claim 1, the acts further comprising: determining whether a parity bit of the data of the first memory page signals a memory fault; and waiting to receive the data of the second memory page in response to the parity bit of the data of the first memory page signaling the memory fault.
 4. The one or more computer-readable storage media of claim 1, the acts further comprising: storing the data of the first memory page in the memory if the data of the first memory page is non-faulty; and storing the data of the second memory page in the memory if the data of the second memory page is non-faulty.
 5. The one or more computer-readable storage media of claim 1, the acts further comprising: canceling the second data request for the second memory page in response to receiving the data of the first memory page and determining that the data of the first memory page is fault-free.
 6. The one or more computer-readable storage media of claim 1, wherein the first memory page comprises phase change memory.
 7. The one or more computer-readable storage media of claim 1, the acts further comprising: dynamically replicating the first memory page as errors are found.
 8. The one or more computer-readable storage media of claim 1, wherein determining the replication policy to follow includes: selecting a lazy replication policy that comprises: placing a read request in a transaction queue for the first memory page; receiving a first returning memory page corresponding to the first memory page, the first returning memory page including the data; and placing a read request in the transaction queue for the second memory page.
 9. A system for improving memory access performance, the system comprising: memory; and one or more processors having instructions stored in the memory, wherein when executed by the one or more processors perform the method comprising: determining a replication policy to follow; replicating a first memory page to create a second memory page, the first memory page and the second memory page including data and located on different memory banks of the memory; receiving a memory access request for the data, the data being included in a set of faulty memory pages including at least a first memory page and a second memory page, wherein the first memory page includes at least one first failed memory block of the first memory page being located at a relative position different from a failed memory block of the second memory page; and requesting a first memory access to the data of the first memory page and requesting a second memory access to the data of the second memory page; receiving the data of the first memory page at the memory controller; determining whether the data of the first memory page is faulty; and waiting to receive the data of the second memory page in response to determining that the data of the first memory page is faulty.
 10. The system of claim 9, wherein the one or more processor further perform the method comprising: inserting a first data write request for the first memory page in the transaction queue; and inserting a second data write request for the second memory page in the transaction queue.
 11. The system of claim 10, wherein the one or more processor further perform the method comprising: removing the second data write request for the second memory page from the transaction queue in response to a completion of a checker-read.
 12. The system of claim 9, wherein the one or more processor further perform the method comprising: receiving and consuming the data of the first memory page without waiting for the data of the second memory page.
 13. The system of claim 9, wherein the memory comprises phase change memory.
 14. The system of claim 9, wherein determining the replication policy to follow includes: selecting a lazy replication policy that comprises: placing a read request in a transaction queue for the first memory page; receiving a first returning memory page corresponding to the first memory page, the first returning memory page including the data; and placing a read request in the transaction queue for the second memory page.
 15. A computer-implemented method for improving memory access performance, the method comprising: determining a replication policy to follow; replicating a first memory page to create a second memory page, the first memory page and the second memory page including data and located on different memory banks of a memory; receiving an incoming memory access request for the data from a memory controller, the data being included in a set of faulty memory pages including at least the first memory page and the second memory page, at least one first failed memory block of the first memory page being located at a relative position different from a second failed memory block of the second memory page; requesting a first memory access to the data of the first memory page and requesting a second memory access to the data of the second memory page; receiving the data of the first memory page at the memory controller; determining whether the data of the first memory page is faulty; and waiting to receive the data of the second memory page in response to determining that the data of the first memory page is faulty.
 16. The method of claim 15, wherein determining whether the data of the first memory page is faulty comprises: determining that a parity bit of the data of the first memory page signals a memory fault.
 17. The method of claim 15, further comprising: storing the data of the second memory page in the memory when the data of the second memory page is non-faulty.
 18. The method of claim 15, wherein the first memory page comprises phase change memory.
 19. The method of claim 15, further comprising: dynamically replicating the first memory page as errors are found.
 20. The method of claim 15, wherein determining the replication policy to follow includes: selecting a lazy replication policy that comprises: placing a read request in a transaction queue for the first memory page; receiving a first returning memory page corresponding to the first memory page, the first returning memory page including the data; and placing a read request in the transaction queue for the second memory page. 